﻿﻿/***************************  Ccay IGrid Editor  ***********************************/
(function(IGrid, Const) {
	// 国际化信息
	var innerCol = IGrid.Const.I18n.innerCol = {
		colHeader : "ccay.common.label.operation"
	};

	/** 注册扩展全屏实现 */
	Ccay.UI.XControl.extendIManager("XGrid", {
		unselectAllRow: function () {
			var grid = this,
				// 清除表头的全选
				selectedHead = grid.getHeadTable().find("." + IGrid.Const.selected.css);
			// 存在将选中样式去掉
			(selectedHead.length > 0) && selectedHead.removeClass(IGrid.Const.selected.css, false);
			// 遍历选中的行，设置选中状态
			grid.getSelectRows(false).each(function(i) {
				gridSelect.rowSelected($(this), false, grid);
			});
		},
		/** @description 设置表头的选中状态
		 *  @param {Boolean} selected 是否选中
		 */
		setSelectHeader: function (selected) {
			var selCol = this.getHeadTable().find(".igrid-selectAll"), selRow, isSelected;
			// 选中行，判断当前页是否全选中，若全选中，则表头的复选框选中
			if (selCol.length) {
				selRow = selCol.parent();
				isSelected = selRow.hasClass(Const.selected.css);
				if (selected && this.getSelectRows().length == this.op._prevSelCount) {
					!isSelected && selRow.addClass(Const.selected.css);
					return false;
				}
				// 取消行，判断表头是否是选中状态，若选中，这取消选中状态
				isSelected && selRow.removeClass(Const.selected.css, false);
			}
		},
		/**
		 * @description 设置分组头选中状态
		 */
		setGroupHeader:function(tr,selected){
			if(event.target){
				var targetTr = event.target.tagName.toLowerCase()=="tr"?$(event.target):$(event.target).parents("tr:first");
				if(targetTr[0]!=tr[0]){
					return;
				}
			}
			if(selected){
				var nextTr=tr.next("tr");
				while(selected && nextTr.length>0 && !nextTr.hasClass("grid-row-group")){
					selected=nextTr.hasClass(Const.selected.css);
					if(!selected){break;}
					nextTr = nextTr.next("tr");					
				}
				var prevTr=tr.prev("tr");
				while(selected && prevTr.length>0 && !prevTr.hasClass("grid-row-group")){
					selected=prevTr.hasClass(Const.selected.css);
					if(!selected){break;}
					prevTr=prevTr.prev("tr");
				}
				selected && tr.prevAll("tr.grid-row-group:first").addClass(Const.selected.css);
			}else{
				tr.prevAll("tr.grid-row-group:first").removeClass(Const.selected.css);
			}
		},
		/**
		 * @description 选中行或取消选中
		 * @param {jqDOM} tr 单行或多行
		 * @param {Boolean} selected 是否选中
		 */
		selectRow:function(tr,selected){
			var grid = this,
				selected = selected ? true : false;
			tr.each(function(){
				gridSelect.rowSelected($(this), selected, grid);
			});
		}
	});
	
	//内置列对象
	IGrid.innerColumn = $.IAdapter();

	var gridSelect = IGrid.innerColumn.gridSelect = {
		/** @description 选择事件
		 *  @param {Object} e 事件对象
		 *  @param {Object} cell 单元格对象
		 *  @param {Object} grid IGrid对象
		 */
		selected : function(e, cell, grid) {
			var tr = cell.parent(), selected;
			// 行渲染form模式下，判断行对象
			tr.hasClass("grid-cell-custom") && (tr = tr.parent());
			selected = !tr.hasClass(Const.selected.css)
			// 多选事件
			if (cell.hasClass("igrid-multi") )
				gridSelect.multiSelected(e, tr, selected, grid);
			// 全选事件
			else if (cell.hasClass("igrid-selectAll"))
				gridSelect.allSelected(e, tr, selected, grid);
			// 单选事件
			else
				gridSelect.singlerSelected(e, tr, selected, grid);
		},
		/** @description 单选事件
		 *  @param {Object} e 事件对象
		 *  @param {Object} tr 行对象
		 *  @param {Boolean} selected 是否是被选中的状态
		 *  @param {Object} grid IGrid对象
		 */
		singlerSelected : function(e, tr, selected, grid) {
			if (!tr.hasClass(Const.selected.css)) {
				var selectedTr = tr.parent().children('tr.' + Const.selected.css);
				// 若有被选中的行，则将选中的状态去掉
				selectedTr.length && this.rowSelected(selectedTr, 0, grid);
			}
			// 设置选中的状态
			this.rowSelected(tr, selected, grid);
		},
		/** @description 全选事件
		 *  @param {Object} e 事件对象
		 *  @param {Object} tr 行对象
		 *  @param {Boolean} selected 是否是被选中的状态
		 *  @param {Object} grid IGrid对象
		 */
		allSelected : function(e, tr, selected, grid) {
			if(grid.getAllRecords().length==0){
				return;			
			}
			// 设置全选的状态
			tr.toggleClass(Const.selected.css, selected);
			
			// 遍历选中的行，设置选中状态
			grid.getSelectRows(selected).each(function(i) {
						gridSelect.rowSelected($(this), selected, grid, e);
					});
			//全选事件接口
			if(grid.op.fnSelectedAll && typeof grid.op.fnSelectedAll === "function"){
				grid.op.fnSelectedAll.call(this,selected,grid);
			}
		},
		/** @description 多选事件
		 *  @param {Object} e 事件对象
		 *  @param {Object} tr 行对象
		 *  @param {Boolean} selected 是否是被选中的状态
		 *  @param {Object} grid IGrid对象
		 */
		multiSelected : function(e, tr, selected, grid) {
			// 设置选中的状态
			this.rowSelected(tr, selected, grid, e);
			// 判断是否是shift键；否则设置shift选择事件
			if (e.shiftKey && grid.op.shiftSelectMode !== false) {
				// 获取开始的行号
				var index = grid.getRowIndex(tr);
				// 若缓存shift键开始值不为空，则循环设置选中状态，直至结束值；否则设置shift选择事件
				if (grid.op._shiftStart != null) {
					var isPrev = grid.op._shiftStart < index;
					while ((isPrev && index > grid.op._shiftStart) || (!isPrev && index < grid.op._shiftStart)) {
						// 若当前行的状态不是缓存的shift键的状态，则设置当前行的状态
						if (tr.hasClass(Const.selected.css) != grid.op._shiftChecked)
							gridSelect.rowSelected(tr, grid.op._shiftChecked, grid,e);
						tr = isPrev ? tr.prev() : tr.next();
						index = grid.getRowIndex(tr);
					}
					// 设置shift选择事件
					this.setShiftSelect(grid.op, null, null);
				} else
					this.setShiftSelect(grid.op, index, selected);
			} else
				this.setShiftSelect(grid.op, null, null);
		},
		/** @description 设置shift选择事件
		 *  @param {Object} op grid的参数配置
		 *  @param {Object} tr 行对象
		 *  @param {Boolean} selected 是否是被选中的状态
		 *  @param {Object} grid IGrid对象
		 */
		setShiftSelect : function(op, index, selected) {
			// 缓存shift键开始值
			op._shiftStart = index;
			// 缓存shift键的状态
			op._shiftChecked = selected;
		},
		/** @description 设置行选中
		 *  @param {Object} tr 行对象
		 *  @param {Boolean} selected 是否是被选中的状态
		 *  @param {Object} grid IGrid对象
		 */
		rowSelected : function(tr, selected, grid, e) {
			// 获取行数据
			var op = grid.op,
				rowData = grid.getRowData(tr),
				rowNo = grid.getRowIndex(tr);
			// 选择行之前执行的方法，返回false，阻止选中
			if (!op.fnBeforeRowSelect || op.fnBeforeRowSelect.call(grid, rowData, tr, rowNo, e) !== false) {
				// 设置数据的状态
				op.Storage.setItemSelected(rowData, selected, tr);
				// 执行选中事件
				op.fnSelected && op.fnSelected.call(grid, selected, tr, rowData, e);
			}
		}
	};
	
	/** 注册内置选择列 */
	IGrid.innerColumn.add("select", function(grid, col) {
				var checkRender = col.checkRender;
				col._module = "igrid-select";
				// 设置多选列的配置
				if (col.multi) {
					col._ctype = "mulitSelect";
					col.headENo = "rowSelect";
					col._headCss = 'grid-select igrid-selectAll';
					col.cssName = 'igrid-multi';
				} else {
					// 设置单选列的配置
					col._ctype = "singleSelect";
					col.cssName = 'igrid-single';
				}
				// 根据场景判断是否需要显示选择框
				if (checkRender) {
					col.cssName = col.cssName + "<% if(" + checkRender + ") { %>" + " grid-select" + "<% } %>";
					col.eNo = "<% if(" + checkRender + ") { %>" + "rowSelect" + "<% } %>";
					grid.op.rowClass.push("${" + checkRender + " ? '' : 'row-noselect'}");
				} else {
					col.cssName += " grid-select";
					col.eNo = "rowSelect";
				}
				// 设置列的field字段
				if (col.field) {
					col.valueField = col.field;
					col.field = null;
				}
				var op = grid.op;
				col.content = "<span/>";
				// 设置选择列的宽度
				col.width = col.width || (op.percentWidth ? '5%' : 35);
				// 设置选择列的冻结
				col.freezeable == null && (col.freezeable = op.allowFreezen);
				// 添加选择列的事件
				op.handler.click.add("rowSelect", gridSelect.selected);
				// 设置选择模式
				op.selectMode = col._ctype;
				// 设置选择字段
				op.selectField = col.valueField;
			});
	
	/** 注册内置操作列 */
	IGrid.innerColumn.add("operate", function(grid, col) {
				col._module = "igrid-icon";
				// 设置操作列的标题
				if (!col.header)
					col.header = innerCol.colHeader;
				// 设置操作列的样式
				if (!col.cssName)
					col.cssName = "center";
				// 设置操作列显示类型
				if (col.btns && col.btns.length) {
					var html = [];
					// 设置列的field字段
					if (col.field) {
						col.valueField = col.field;
						col.field = null;
					}
					// 生成按钮
					for (var i = 0, len = col.btns.length; i < len; i++) {
						var btn = col.btns[i], click = '', attrs = "", field = btn.field || col.valueField;
						// 判断点击事件的类型
						if (typeof(btn.click) == "string")
							click = btn.click;
						else {
							// 生成事件编码
							var no = $.newGuid("operate");
							attrs = 'eno="' + no + '"';
							// 注册点击事件
							regGridOperate(grid.op, no, btn.click);
						}
						field && (attrs += ' val="${' + field + '}"');
						// 生成按钮模板，若是标识显示，则全部显示；标示不显示，则全部不显示；默认情况，则新增数据部显示
						if (btn.isShow !== false) {
							html.push(!btn.isShow ? "<% if(!data._inserted) { %>" : "",
								Ccay.UI.button(btn.text, click, btn.permission, btn.type || "link", btn.imgtype, btn.isIi8n, attrs),
								!btn.isShow ? "<% } %>" : "");
						}
					}
					col.content = html.join("");
				}
			});
	// 注册点击事件
	function regGridOperate(op, no, operate) {
		op.handler.click.add(no, function(e, btn, grid) {
					var value = IGrid.Helper.attrValue(btn);
					if (value == null)
						value = grid.getRowData(btn);
					operate.call(btn,value,grid);
				});
	}

	var InnerColumn = {
		/** @description 内置列的初始化
		 *  @param {Object} grid IGrid对象
		 *  @param {Object} col 列的配置信息
		 *  @param {Object} op grid的参数配置
		 */
		init : function(grid, col, op) {
			if (col.columnType) {
				// 通过类型进行初始化
				var innerCol = IGrid.innerColumn.get(col.columnType);
				if (innerCol) {
					col.inner = true;
					// 内置列初始化
					innerCol(grid, col);
				}
			}
		}
	};

	/** 注册内置列插件 */
	Ccay.UI.XControl.addPlugin("XGrid", "innerColumn", {
				preInit : function(grid, op) {
					// 内置列设置
					if (op.columns) {
						op.handler.setColumn.add(InnerColumn.init);
					}
					// 点击行即勾选事件设置 add by l00195395 2013-12-31
					if(op.clickRow2Check === true){
						// 若用户设置了onRowClick
						var onCellClick;
						// 原始onRowClick事件
						op.onCellClick && (onCellClick = op.onCellClick);
						
						op.onCellClick = function(cellData, rowData , target, tr, colIndex, rowIndex, col, grid, e){
							// 排除点击列头
							if(!tr.parent().hasClass("igrid-head")){
								var cell;
								// tree-grid时
								if(op.rowRender == "tree"){
									//点击文件夹展开时不处理
									if(e && !$(e.target).hasClass("tree-icon")){
										cell = tr.find(".tree-chk:first");
										IGrid.tree.nodeSelect(null, cell, grid);
									}
								}else{
									//点击勾选框时不处理
									if(!target.hasClass("grid-select")){
										cell = tr.children(".grid-select");
										gridSelect.selected({}, cell, grid);
									}
								}
							}
							// 执行原始onRowClick事件设置
							onCellClick && onCellClick.call(grid, cellData, rowData , target, tr, colIndex, rowIndex, col, grid, e);
						}
					}
				},
				build : function(grid, op) {
					if (!op._reIniting) {
						// 数据仓库中添加选择时的委托方法
						op.Storage.Trigger.select.add(function(item, selected, tr) {
							// 设置行选中样式
							tr && tr.toggleClass(Const.selected.css, selected);
							op.rowRender=="group" && tr && !tr.hasClass("grid-row-group") && grid.setGroupHeader(tr,selected);
							// 设置表头的选中状态
							grid.setSelectHeader(selected);
						});
					}
				},
				clear : function(grid, op) {
					// 重新初始化时，清除序号列
					op.showSeq && op.columns && op.columns.shift();
				}
			});

})(Ccay.UI.IGrid, Ccay.UI.IGrid.Const);